/*
 * funcionesEncolamiento.c
 *
 *  Created on: 10/11/2011
 *      Author: utn_so
 */


#include "planificador.h"
//#include "/home/utn_so/Desarrollo/Workspace/Operativos/Commons/funciones_NIPC.h"



/*void serializeNIPC(struct nipc_protocol * toSerialize, char**result) {
	*result = malloc(sizeof(toSerialize)+1);
	memcpy(*result, toSerialize->type, 1);
	memcpy(*result, toSerialize->payloadLength, sizeof(int32_t));
	memcpy(*result, toSerialize->payload, sizeof(toSerialize->payload));
	memcpy(*result, "/0", 1);
}*/
void nodoEscritura_crear(struct estructuraEscribir **punteroEstructura,int32_t sector,char infoSector[512])
{
	*punteroEstructura=calloc(1,sizeof(struct estructuraEscribir));
	(*punteroEstructura)->numeroSector=sector;
	memcpy((*punteroEstructura)->infoSector,infoSector,512);
	(*punteroEstructura)->siguiente=NULL;
}

void nodoLectura_crear(struct estructuraLeer **punteroEstructura,int32_t sector,int32_t esTrace,int32_t esSincro)
{
	*punteroEstructura=(struct estructuraLeer*)calloc(1,sizeof(struct estructuraLeer));
	(*punteroEstructura)->numeroSector=sector;
	(*punteroEstructura)->traceONoTrace=esTrace;
	(*punteroEstructura)->sincro=esSincro;
	(*punteroEstructura)->siguiente=NULL;
}

void colaEscritura_meter(struct estructuraEscribir **punteroFte,struct estructuraEscribir **punteroFin, struct estructuraEscribir **punteroEstructura)
{
	pthread_mutex_lock(&mutexInfoSector);
	if(*punteroFte==NULL)
		{
			*punteroFte=*punteroEstructura;
		}
	else
		{
		pthread_mutex_lock(&mutexInfoSector2);
			(*punteroFin)->siguiente=*punteroEstructura;
		pthread_mutex_unlock(&mutexInfoSector2);
		}
	pthread_mutex_unlock(&mutexInfoSector);
	*punteroFin=*punteroEstructura;
}

void colaLectura_meter(struct estructuraLeer **punteroFte,struct estructuraLeer **punteroFin, struct estructuraLeer **punteroEstructura)
{
	struct estructuraLeer*auxiliar;
	struct estructuraLeer*anterior;
	if(*punteroFte==NULL)
		{
		//pthread_mutex_lock(&mutexSincro);
			*punteroFte=*punteroEstructura;
		//pthread_mutex_unlock(&mutexSincro);
		}
	else
		{
		auxiliar=*punteroFte;

		while(auxiliar){
			anterior=auxiliar;
			auxiliar=auxiliar->siguiente;
		}
	//	pthread_mutex_lock(&mutexSincro);
		anterior->siguiente=*punteroEstructura;
		//pthread_mutex_unlock(&mutexSincro);

		}
	//*punteroFin=*punteroEstructura;
}

void colaLectura_liberar(struct estructuraLeer **punteroFrente,struct estructuraLeer **punteroFin)
{
	struct estructuraLeer *punteroListaAuxiliar;
	while (*punteroFin!=NULL)
		{
		punteroListaAuxiliar=*punteroFrente;

		(*punteroFrente)=(*punteroFrente)->siguiente;
		printf("numero de sector %d y es trace? %d\n",punteroListaAuxiliar->numeroSector,punteroListaAuxiliar->traceONoTrace);
		if(*punteroFrente==NULL)
			{
			*punteroFin=NULL;
			}
		free(punteroListaAuxiliar);
		punteroListaAuxiliar=NULL;
		}
}

void sectores_enconlar() {
	struct estructuraLeer *nodoNuevoAleer;
	char *listaDeSectoresSinSectorAgregado;
	char*puntero;
	int32_t contador=0;

	listaDeSectoresSinSectorAgregado=(char *)calloc(1,(strlen(cadenaDeMensajeRecibido)+1)*sizeof(char));
	memset(listaDeSectoresSinSectorAgregado,'\0',strlen(cadenaDeMensajeRecibido));
	memcpy(listaDeSectoresSinSectorAgregado,cadenaDeMensajeRecibido,strlen(cadenaDeMensajeRecibido));
	puntero=strtok(listaDeSectoresSinSectorAgregado,"trace");
	printf ("Spliteando el string \"%s\" en los siguientes tokens:\n",listaDeSectoresSinSectorAgregado);
	puntero = strtok (listaDeSectoresSinSectorAgregado,"trace(,)\n");
	while (puntero != NULL) {
		contador++;
		nodoLectura_crear(&nodoNuevoAleer,atoi(puntero),1,0);
		colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &nodoNuevoAleer);
		printf ("%d\n", nodoNuevoAleer->numeroSector);
		puntero = strtok (NULL, "trace(,)\n");
		nodoNuevoAleer=NULL;
	}
	printf("vos ingresaste %d sectores\n",contador);
	/*
	if(listaDeSectoresSinSectorAgregado) {
		while((auxiliar!=',')&&(auxiliar!=')')&&(posicionHastaComa<(int32_t)strlen(listaDeSectoresSinSectorAgregado))) {
			auxiliar=listaDeSectoresSinSectorAgregado[posicionHastaComa+1];
			posicionHastaComa++;
		}
		if((auxiliar!=',')&&(auxiliar!=')')) {
			free(nodoNuevoAleer);
			free(listaDeSectoresSinSectorAgregado);
			printf("nada\n");
		}
		sectorAAgregar=(char *) calloc(1,sizeof(char)*(posicionHastaComa+1));
		memcpy(sectorAAgregar,listaDeSectoresSinSectorAgregado,posicionHastaComa);
		free(listaDeSectoresSinSectorAgregado);
		nodoNuevoAleer->numeroSector=atoi(sectorAAgregar);
		nodoNuevoAleer->siguiente=NULL;
		listaDeSectores=nodoNuevoAleer;
		printf("Un sector a agregar:%d\n",nodoNuevoAleer->numeroSector);
		listaDeSectoresSinSectorAgregado=(char *)calloc(1,(strlen(cadenaDeMensajeRecibido)-strlen("(,")-strlen(sectorAAgregar))*strlen(cadenaDeMensajeRecibido));
		memcpy(listaDeSectoresSinSectorAgregado,cadenaDeMensajeRecibido+(strlen("(,"))+strlen(sectorAAgregar),strlen(cadenaDeMensajeRecibido)-strlen("(,")-strlen(sectorAAgregar));
		free(sectorAAgregar);
		while(auxiliar!=')') {
			posicionHastaComa=-1;
			auxiliar='0';
			while((auxiliar!=',')&&(auxiliar!=')')) {
				auxiliar=listaDeSectoresSinSectorAgregado[posicionHastaComa+1];
				posicionHastaComa++;
			}
			sectorAAgregar=(char *) calloc(1,sizeof(char)*(posicionHastaComa+1));
			memcpy(sectorAAgregar,listaDeSectoresSinSectorAgregado,posicionHastaComa);
			nodoNuevoAleer=(struct estructuraLeer*)calloc(1,sizeof(struct estructuraLeer));
			nodoNuevoAleer->numeroSector=atoi(sectorAAgregar);
			nodoNuevoAleer->siguiente=NULL;
			listaAuxiliar=listaDeSectores;
			//listaDeSectores=listaAuxiliar;
			printf("Un sector a agregar:%d\n",nodoNuevoAleer->numeroSector);
			while(listaAuxiliar->siguiente) {
				listaAuxiliar = listaAuxiliar->siguiente;
			}
			listaAuxiliar->siguiente=nodoNuevoAleer;
			listaDeSectoresSinSectorAgregadoAnterior=(char *)calloc(1,sizeof(char)*(strlen(listaDeSectoresSinSectorAgregado)+1));
			memcpy(listaDeSectoresSinSectorAgregadoAnterior,listaDeSectoresSinSectorAgregado,strlen(listaDeSectoresSinSectorAgregado));
			free(listaDeSectoresSinSectorAgregado);
			listaDeSectoresSinSectorAgregado=(char *)calloc(1,(strlen(listaDeSectoresSinSectorAgregadoAnterior)-strlen(sectorAAgregar)-strlen(","))*sizeof(cadenaDeMensajeRecibido));
			memcpy(listaDeSectoresSinSectorAgregado,listaDeSectoresSinSectorAgregadoAnterior+strlen(sectorAAgregar)+strlen(","),strlen(listaDeSectoresSinSectorAgregadoAnterior)-strlen(sectorAAgregar)-strlen(","));
			free(listaDeSectoresSinSectorAgregadoAnterior);
			free(sectorAAgregar);
		}
		free(listaDeSectoresSinSectorAgregado);
	} else {
		free(nodoNuevoAleer);
		free(listaDeSectoresSinSectorAgregado);
	}
	return ;*/
	colaLectura_liberar(&punteroFrenteLeer,&punteroFinLeer);
}
void mensaje_detectar(void){
struct nipc_protocol punteroNIPC;
char**resultado;

if (memcmp(cadenaDeMensajeRecibido,"info:",strlen("info:"))==0) {
				memcpy(cadenaDeMensajeRecibido,"Esto es un hardcodeo de lo que tendra info\n",strlen("Esto es un hardcodeo de lo que tendra info\n"));
				variableAuxiliar=strlen("Esto es un hardcodeo de lo que tendra info\n");
			} else if (memcmp(cadenaDeMensajeRecibido,"clean",strlen("clean"))==0) {
				memcpy(cadenaDeMensajeRecibido,"Esto es un hardcodeo de lo que tendra clean\n",strlen("Esto es un hardcodeo de lo que tendra clean\n"));
				variableAuxiliar=strlen("Esto es un hardcodeo de lo que tendra clean\n");
			} else	if (memcmp(cadenaDeMensajeRecibido,"trace(",strlen("trace("))==0) {
				sectores_enconlar();
				memcpy(cadenaDeMensajeRecibido,"Esto es un hardcodeo de lo que tendra trace\n",strlen("Esto es un hardcodeo de lo que tendra trace\n"));
				variableAuxiliar=strlen("Esto es un hardcodeo de lo que tendra trace\n");
			} else	if (memcmp(cadenaDeMensajeRecibido,"salir",strlen("salir"))==0) {
				printf("Cerrar consola\n");
				hecho=1;
			} else {
				memcpy(cadenaDeMensajeRecibido,"Usted no ha escrito ni \'clean\' ni \'trace\' ni \'info:\'\n",strlen("Usted no ha escrito ni \'clean\' ni \'trace\' ni \'info:\'\n"));
				variableAuxiliar=strlen("Usted no ha escrito ni \'clean\' ni \'trace(\' ni \'info:\'\n");
/*
				punteroNIPC=calloc(1,sizeof(struct nipc_protocol));
				punteroNIPC->type='1';
				punteroNIPC->payloadLength=variableAuxiliar;
				punteroNIPC->payload=calloc(1,variableAuxiliar+1);
				memcpy(punteroNIPC->payload,cadenaDeMensajeRecibido,variableAuxiliar);
				punteroNIPC->numeroSector=0;

				serializeNIPC(punteroNIPC,&resultado);
				printf("resultado %s\n",resultado);
*/
			}
}
void nodoColaLectura_liberar(struct estructuraLeer **punteroFrente,struct estructuraLeer **punteroFin)
{
	struct estructuraLeer *punteroListaAuxiliar;

		punteroListaAuxiliar=*punteroFrente;
		(*punteroFrente)=(*punteroFrente)->siguiente;

		if(*punteroFrente==NULL)
			{
			*punteroFin=NULL;
			}
		free(punteroListaAuxiliar);
		punteroListaAuxiliar=NULL;

}

void nodoColaEscritura_liberar(struct estructuraEscribir **punteroFrente,struct estructuraEscribir **punteroFin)
{
	struct estructuraEscribir *punteroListaAuxiliar;

		punteroListaAuxiliar=*punteroFrente;
		(*punteroFrente)=(*punteroFrente)->siguiente;

		if(*punteroFrente==NULL)
			{
			*punteroFin=NULL;
			}
		free(punteroListaAuxiliar);
		punteroListaAuxiliar=NULL;

}

void meterNodosParaElTrace(char *sectoresAParsear){

	int32_t sector1, sector2, sector3, sector4, sector5, cantidad;
	struct estructuraLeer *punteroANodoNuevoLeer = NULL;

	cantidad = contarCaracter(sectoresAParsear, ' ');
	cantidad++;

	switch(cantidad){
		case 1: sscanf(sectoresAParsear,"%d",&sector1);
				traceTotal = 1;
			break;
		case 2: sscanf(sectoresAParsear,"%d %d",&sector1, &sector2);
				traceTotal = 2;
			break;
		case 3: sscanf(sectoresAParsear,"%d %d %d",&sector1, &sector2, &sector3);
				traceTotal = 3;
			break;
		case 4: sscanf(sectoresAParsear,"%d %d %d %d",&sector1, &sector2, &sector3, &sector4);
				traceTotal = 4;
			break;
		case 5: sscanf(sectoresAParsear,"%d %d %d %d %d",&sector1, &sector2, &sector3, &sector4, &sector5);
				traceTotal = 5;
			break;
		default:
			break;
	}

	nodoLectura_crear(&punteroANodoNuevoLeer,sector1, 1,0);
	colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &punteroANodoNuevoLeer);

	if (cantidad > 1){
		nodoLectura_crear(&punteroANodoNuevoLeer,sector2, 1,0);
		colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &punteroANodoNuevoLeer);
		if (cantidad > 2){
			nodoLectura_crear(&punteroANodoNuevoLeer,sector3, 1,0);
			colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &punteroANodoNuevoLeer);
			if (cantidad > 3){
				nodoLectura_crear(&punteroANodoNuevoLeer,sector4, 1,0);
				colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &punteroANodoNuevoLeer);
				if (cantidad > 4){
					nodoLectura_crear(&punteroANodoNuevoLeer,sector5, 1,0);
					colaLectura_meter(&punteroFrenteLeer,&punteroFinLeer, &punteroANodoNuevoLeer);
				}
			}
		}
	}

}

int32_t contarCaracter(char *cadena, char caracterAContar){

	char encontrameUnGuion='0';
	int encontrado = 0;
	int recorerPalabra = 0;

	while(cadena[recorerPalabra]!= '\0')
		{
		if(cadena[recorerPalabra] == caracterAContar)
			{
			encontrado++;
			}
		recorerPalabra++;
		}

	return encontrado;

}








